# # -*- coding: utf-8 -*-
#
# """
# @author: 猿小天
# @contact: QQ:1638245306
# @Created on: 2021/6/3 003 0:30
# @Remark: 角色管理
# """
# from rest_framework import serializers
# from rest_framework.decorators import action
# from rest_framework.permissions import IsAuthenticated
#
# from dvadmin.system.models import Role, Menu, MenuButton, Dept
# from dvadmin.system.views.dept import DeptSerializer
# from dvadmin.system.views.menu import MenuSerializer
# from dvadmin.system.views.menu_button import MenuButtonSerializer
# from dvadmin.utils.json_response import SuccessResponse, DetailResponse
# from dvadmin.utils.serializers import CustomModelSerializer
# from dvadmin.utils.validator import CustomUniqueValidator
# from dvadmin.utils.viewset import CustomModelViewSet
#
#
# class RoleSerializer(CustomModelSerializer):
#     """
#     角色-序列化器
#     """
#
#     class Meta:
#         model = Role
#         fields = "__all__"
#         read_only_fields = ["id"]
#
#
# class RoleInitSerializer(CustomModelSerializer):
#     """
#     初始化获取数信息(用于生成初始化json文件)
#     """
#
#     class Meta:
#         model = Role
#         fields = ['name', 'key', 'sort', 'status', 'admin', 'data_range', 'remark',
#                   'creator', 'dept_belong_id']
#         read_only_fields = ["id"]
#         extra_kwargs = {
#             'creator': {'write_only': True},
#             'dept_belong_id': {'write_only': True}
#         }
#
#
# class RoleCreateUpdateSerializer(CustomModelSerializer):
#     """
#     角色管理 创建/更新时的列化器
#     """
#     menu = MenuSerializer(many=True, read_only=True)
#     dept = DeptSerializer(many=True, read_only=True)
#     permission = MenuButtonSerializer(many=True, read_only=True)
#     key = serializers.CharField(max_length=50,
#                                 validators=[
#                                     CustomUniqueValidator(queryset=Role.objects.all(), message="权限字符必须唯一")])
#     name = serializers.CharField(max_length=50, validators=[CustomUniqueValidator(queryset=Role.objects.all())])
#
#     def validate(self, attrs: dict):
#         return super().validate(attrs)
#
#     def save(self, **kwargs):
#         is_superuser = self.request.user.is_superuser
#         if not is_superuser:
#             self.validated_data.pop('admin')
#         data = super().save(**kwargs)
#         data.dept.set(self.initial_data.get('dept', []))
#         data.menu.set(self.initial_data.get('menu', []))
#         data.permission.set(self.initial_data.get('permission', []))
#         return data
#
#     class Meta:
#         model = Role
#         fields = '__all__'
#
#
# # class MenuPermissonSerializer(CustomModelSerializer):
# #     """
# #     菜单的按钮权限
# #     """
# #     menuPermission = MenuButtonSerializer(many=True, read_only=True)
# #     # def get_menuPermission(self, instance):
# #     #     is_superuser = self.request.user.is_superuser
# #     #     print(is_superuser)
# #     #     if is_superuser:
# #     #         queryset = MenuButton.objects.fillter(id__in=menu_permission_id_list,menu__id=instance.id)
# #     #     else:
# #     #         menu_permission_id_list = self.request.user.role.values_list('permission',flat=True)
# #     #         queryset = MenuButtonSerializer(id__in=menu_permission_id_list,menu__id=instance.id)
# #     #     serializer = MenuButtonSerializer(queryset,many=True,read_only=True)
# #     #     return serializer.data
# #
# #     class Meta:
# #         model = Menu
# #         fields = '__all__'
#
# class MenuPermissonSerializer(CustomModelSerializer):
#     """
#     菜单的按钮权限
#     """
#     # menuPermission = serializers.SerializerMethodField()
#     menuPermission = MenuButtonSerializer(many=True,read_only=True)
#     class Meta:
#         model = Menu
#         # fields = ['id', 'parent', 'name', 'menuPermission']
#         fields = '__all__'
#
#
# class RoleViewSet(CustomModelViewSet):
#     """
#     角色管理接口
#     list:查询
#     create:新增
#     update:修改
#     retrieve:单例
#     destroy:删除
#     """
#     queryset = Role.objects.all()
#     serializer_class = RoleSerializer
#     create_serializer_class = RoleCreateUpdateSerializer
#     update_serializer_class = RoleCreateUpdateSerializer
#
#     @action(methods=['GET'], detail=True, permission_classes=[])
#     def roleId_get_menu(self, request, *args, **kwargs):
#         print(10000000000000000)
#         queryset = Menu.objects.filter(status=1).all()
#         print(queryset)
#         serializer = MenuPermissonSerializer(queryset, many=True)
#         # return DetailResponse(data=serializer.data)
#         return SuccessResponse(data=serializer.data)
#
#     # @action(methods=['GET'], detail=False, permission_classes=[IsAuthenticated])
#     # def role_get_menu(self, request):
#     #     """根据当前用户的角色返回角色拥有的菜单"""
#     #     is_superuser = request.user.is_superuser
#     #     is_admin = request.user.role.values_list('admin',flat=True)
#     #     if is_superuser or True in is_admin:
#     #         queryset = Menu.objects.filter(status=1).all()
#     #     else:
#     #         menu_id_list = request.user.role.values_list('menu',flat=True)
#     #         queryset = Menu.objects.filter(id__in=menu_id_list)
#     #     queryset = self.filter_queryset(queryset)
#     #     serializer = MenuPermissonSerializer(queryset, many=True,request=request)
#     #     return SuccessResponse(data=serializer.data)
#     @action(methods=['GET'], detail=False, permission_classes=[IsAuthenticated])
#     def data_scope(self, request):
#         is_superuser = request.user.is_superuser
#         role_queryset = Role.objects.filter(users__id=request.user.id).values_list('data_range', flat=True)
#         print(role_queryset)
#         if is_superuser:
#             data = [
#                 {
#                     "value": 0,
#                     "label": '仅本人数据权限'
#                 },
#                 {
#                     "value": 1,
#                     "label": '本部门及以下数据权限'
#                 },
#                 {
#                     "value": 2,
#                     "label": '本部门数据权限'
#                 },
#                 {
#                     "value": 3,
#                     "label": '全部数据权限'
#                 },
#                 {
#                     "value": 4,
#                     "label": '自定义数据权限'
#                 }
#             ]
#         else:
#             data = []
#             data_range_list = list(set(role_queryset))
#             for item in data_range_list:
#                 if item == 0:
#                     data = [{
#                         "value": 0,
#                         "label": '仅本人数据权限'
#                     }]
#                 elif item == 1:
#                     data = [{
#                         "value": 0,
#                         "label": '仅本人数据权限'
#                     }, {
#                         "value": 1,
#                         "label": '本部门及以下数据权限'
#                     },
#                         {
#                             "value": 2,
#                             "label": '本部门数据权限'
#                         }]
#                 elif item == 2:
#                     data = [{
#                         "value": 0,
#                         "label": '仅本人数据权限'
#                     },
#                         {
#                             "value": 2,
#                             "label": '本部门数据权限'
#                         }]
#                 elif item == 3:
#                     data = [{
#                         "value": 0,
#                         "label": '仅本人数据权限'
#                     },
#                         {
#                             "value": 3,
#                             "label": '全部数据权限'
#                         }, ]
#                 elif item == 4:
#                     data = [{
#                         "value": 0,
#                         "label": '仅本人数据权限'
#                     },
#                         {
#                             "value": 4,
#                             "label": '自定义数据权限'
#                         }]
#                 else:
#                     data = []
#                 print(data)
#         return DetailResponse(data=data)
#
#     @action(methods=['GET'], detail=False, permission_classes=[IsAuthenticated])
#     def data_scope_dept(self, request):
#         """根据当前角色获取部门信息"""
#         is_superuser = request.user.is_superuser
#         if is_superuser:
#             queryset = Dept.objects.values('id', 'name', 'parent')
#         else:
#             dept_list = request.user.role.values_list('dept', flat=True)
#             queryset = Dept.objects.filter(id__in=dept_list).values('id', 'name', 'parent')
#         return DetailResponse(data=queryset)
# -*- coding: utf-8 -*-

"""
@author: 猿小天
@contact: QQ:1638245306
@Created on: 2021/6/3 003 0:30
@Remark: 角色管理
"""
from rest_framework import serializers
from rest_framework.decorators import action
from rest_framework.permissions import IsAuthenticated

from dvadmin.system.models import Role, Menu, MenuButton, Dept
from dvadmin.system.views.dept import DeptSerializer
from dvadmin.system.views.menu import MenuSerializer
from dvadmin.system.views.menu_button import MenuButtonSerializer
from dvadmin.utils.json_response import SuccessResponse, DetailResponse
from dvadmin.utils.serializers import CustomModelSerializer
from dvadmin.utils.validator import CustomUniqueValidator
from dvadmin.utils.viewset import CustomModelViewSet


# 这是一个类定义，类名为RoleSerializer，
# 它继承自CustomModelSerializer，用于序列化Role对象。下面是加上注释后的代码：
class RoleSerializer(CustomModelSerializer):
    """
    角色-序列化器
    """

    class Meta:
        model = Role
        fields = "__all__"
        read_only_fields = ["id"]



# 这是一个类定义，类名为RoleInitSerializer，用于初始化获取角色信息（用于生成初始化json文件）。下面是加上注释后的代码：
class RoleInitSerializer(CustomModelSerializer):
    """
    初始化获取数信息(用于生成初始化json文件)
    """

    # 这段代码定义了一个 Django REST Framework 的 ModelSerializer 类，用于序列化和反序列化 Role 模型。
    # Meta 类定义了该 ModelSerializer 的元数据，包括要序列化/反序列化的字段、只读字段、额外的关键字参数等。
    # 以下是加上中文注释后的代码：
    class Meta:
        # 指定要序列化/反序列化的模型类
        model = Role
        # 指定要序列化的字段
        fields = ['name', 'key', 'sort', 'status', 'admin', 'data_range', 'remark',
                  'creator', 'dept_belong_id']
        # 指定只读字段
        read_only_fields = ["id"]
        # 定义额外的关键字参数
        extra_kwargs = {
            'creator': {'write_only': True},
            'dept_belong_id': {'write_only': True}
        }


# 这是一个名为 RoleCreateUpdateSerializer 的类，它是用于处理角色管理的创建/更新操作的序列化器。下面是加上注释后的代码：
class RoleCreateUpdateSerializer(CustomModelSerializer):
    """
    角色管理 创建/更新时的列化器
    """
    # 定义一个 menu 字段，使用 MenuSerializer 进行序列化，并将 many 设置为 True，表示可以一次性序列化多个对象，read_only 设置为 True，表示只读
    menu = MenuSerializer(many=True, read_only=True)
    # 定义一个 dept 字段，使用 DeptSerializer 进行序列化，并将 many 设置为 True，表示可以一次性序列化多个对象，read_only 设置为 True，表示只读
    dept = DeptSerializer(many=True, read_only=True)
    # 定义一个 permission 字段，使用 MenuButtonSerializer 进行序列化，并将 many 设置为 True，表示可以一次性序列化多个对象，read_only 设置为 True，表示只读
    permission = MenuButtonSerializer(many=True, read_only=True)
    # 定义一个 key 字段，最大长度为 50，使用 CustomUniqueValidator 进行校验，校验条件为权限字符必须唯一
    key = serializers.CharField(max_length=50,
                                # 使用 CustomUniqueValidator 进行校验
                                validators=[CustomUniqueValidator(queryset=Role.objects.all(), message="权限字符必须唯一")])
    # 定义一个 name 字段，最大长度为 50，使用 CustomUniqueValidator 进行校验，校验条件为角色名称必须唯一
    name = serializers.CharField(max_length=50, validators=[CustomUniqueValidator(queryset=Role.objects.all())])


    # 这段代码用于对 ModelForm 进行验证，其中的 validate 函数是 ModelForm 的一个内置方法，用于对表单数据进行验证。下面是加上注释后的代码：
    def validate(self, attrs: dict):
        # 调用父类 ModelForm 的 validate 函数，并将 attrs 作为参数传递
        return super().validate(attrs)



    # 这段代码用于保存用户对象，在保存用户对象时，需要检查用户是否为超级用户，如果不是，则需要删除一些敏感信息。下面是加上注释后的代码：
    def save(self, **kwargs):
        # 判断用户是否为超级用户
        is_superuser = self.request.user.is_superuser
        # 如果不是，则需要删除一些敏感信息
        if not is_superuser:
            self.validated_data.pop('admin')
        # 调用父类方法保存用户对象
        data = super().save(**kwargs)
        # 设置用户部门
        data.dept.set(self.initial_data.get('dept', []))
        # 设置用户菜单
        data.menu.set(self.initial_data.get('menu', []))
        # 设置用户权限
        data.permission.set(self.initial_data.get('permission', []))
        # 返回保存的用户对象
        return data


    # 这段代码定义了一个 Django 模型类 Role 的元类，其中包含所有字段。下面是加上注释后的代码：
    class Meta:
        # 定义模型类为 Role
        model = Role
        # 包含所有字段
        fields = '__all__'




# 这段代码定义了一个名为 MenuPermissonSerializer 的类，该类继承自 CustomModelSerializer，用于序列化菜单的按钮权限。下面是加上注释后的代码：
class MenuPermissonSerializer(CustomModelSerializer):
    """
    菜单的按钮权限
    """
    # 定义一个名为 menuPermission 的序列化方法
    # menuPermission = serializers.SerializerMethodField()
    #
    # # 这段代码用于获取菜单的权限，根据用户的角色和菜单的关系来确定用户是否有权限访问该菜单。下面是加上注释后的代码：
    # def get_menuPermission(self, instance):
    #     # 判断用户是否为超级用户
    #     is_superuser = self.request.user.is_superuser
    #     # 如果是超级用户，则直接获取该菜单下的所有按钮权限
    #     if is_superuser:
    #         queryset = MenuButton.objects.filter(menu__id=instance.id)
    #     # 如果不是超级用户，则需要根据用户的角色和菜单的关系来确定用户是否有权限访问该菜单
    #     else:
    #         menu_permission_id_list = self.request.user.role.values_list('permission', flat=True)
    #         queryset = MenuButton.objects.filter(id__in=menu_permission_id_list, menu__id=instance.id)
    #     # 使用 MenuButtonSerializer 序列化器将查询集转换为 JSON 数据
    #     serializer = MenuButtonSerializer(queryset, many=True, read_only=True)
    #     # 返回 JSON 数据
    #     return serializer.data
    menuPermission = MenuButtonSerializer(many=True, read_only=True)

    class Meta:
        model = Menu
        fields = '__all__'

    # 这段代码定义了一个 Django 模型的元类，用于指定该模型的字段。下面是加上注释后的代码：
    class Meta:
        # 指定要序列化/反序列化的模型类
        model = Menu
        # 指定要序列化的字段
        fields = '__all__'


# 这是一个 RoleViewSet 的类，它实现了对角色的管理。下面是加上注释后的代码：
class RoleViewSet(CustomModelViewSet):
    """
    角色管理接口
    list:查询
    create:新增
    update:修改
    retrieve:单例
    destroy:删除
    """
    # 这段代码定义了一个 Role 管理器，它使用 RoleSerializer 类进行序列化和反序列化，并使用 RoleCreateUpdateSerializer 类进行创建和更新。
    # 它还定义了搜索字段，这些字段可以用于搜索角色。下面是加上注释后的代码：
    # - queryset：定义要使用的查询集，即要查询的模型对象。
    # - serializer_class：定义序列化器类，用于将模型对象转换为JSON格式的数据。
    # - create_serializer_class：定义创建序列化器类，用于将用户提交的JSON格式的数据转换为模型对象。
    # - update_serializer_class：定义更新序列化器类，用于将用户提交的更新JSON格式的数据转换为模型对象。
    # - search_fields：定义搜索字段，用于实现搜索功能。
    # queryset = Role.objects.all()  # 定义要使用的查询集
    # serializer_class = RoleSerializer  # 定义序列化器类
    # create_serializer_class = RoleCreateUpdateSerializer  # 定义创建序列化器类
    # update_serializer_class = RoleCreateUpdateSerializer  # 定义更新序列化器类
    # search_fields = ['name', 'key']

    # 这段代码用于根据当前用户的角色返回角色拥有的菜单。下面是加上注释后的代码：
    # @action(methods=['GET'], detail=False, permission_classes=[IsAuthenticated])
    # def roleId_get_menu(self, request):
    #     """根据当前用户的角色返回角色拥有的菜单"""
    #     # 判断当前用户是否为超级用户或拥有管理员权限
    #     is_superuser = request.user.is_superuser
    #     is_admin = request.user.role.values_list('admin', flat=True)
    #     if is_superuser or True in is_admin:
    #         # 如果是，则获取所有菜单
    #         queryset = Menu.objects.filter(status=1).all()
    #     else:
    #         # 如果不是，则获取当前用户拥有的菜单ID列表
    #         menu_id_list = request.user.role.values_list('menu', flat=True)
    #         # 根据菜单ID列表获取菜单
    #         queryset = Menu.objects.filter(id__in=menu_id_list)
    #     # queryset = self.filter_queryset(queryset)
    #     # 使用 MenuPermissonSerializer 序列化器将菜单数据转换为 JSON 格式
    #     serializer = MenuPermissonSerializer(queryset, many=True, request=request)
    #     # 返回 DetailResponse 对象，包含转换后的菜单数据
    #     return DetailResponse(data=serializer.data)
    queryset = Role.objects.all()
    serializer_class = RoleSerializer
    create_serializer_class = RoleCreateUpdateSerializer
    update_serializer_class = RoleCreateUpdateSerializer

    @action(methods=['GET'], detail=True, permission_classes=[])
    def roleId_get_menu(self, request, *args, **kwargs):
        """通过角色id获取该角色用于的菜单"""
        # instance = self.get_object()
        # queryset = instance.menu.all()
        queryset = Menu.objects.filter(status=1).all()
        serializer = MenuPermissonSerializer(queryset, many=True)
        return SuccessResponse(data=serializer.data)

    # 这段代码用于处理用户的数据范围权限问题，根据用户的身份和角色，返回用户可以访问的范围。下面是加上中文注释后的代码：
    @action(methods=['GET'], detail=False, permission_classes=[IsAuthenticated])
    def data_scope(self, request):
        # 判断用户是否为超级用户
        is_superuser = request.user.is_superuser
        # 根据用户 ID 查询用户所属的角色
        role_queryset = Role.objects.filter(users__id=request.user.id).values_list('data_range', flat=True)
        # 如果用户是超级用户，则返回所有数据范围
        if is_superuser:
            data = [
                {
                    "value": 0,
                    "label": '仅本人数据权限'
                },
                {
                    "value": 1,
                    "label": '本部门及以下数据权限'
                },
                {
                    "value": 2,
                    "label": '本部门数据权限'
                },
                {
                    "value": 3,
                    "label": '全部数据权限'
                },
                {
                    "value": 4,
                    "label": '自定义数据权限'
                }
            ]
        # 如果用户不是超级用户，则根据用户的角色返回相应的数据范围
        else:
            data = []
            data_range_list = list(set(role_queryset))
            for item in data_range_list:
                if item == 0:
                    data = [{
                        "value": 0,
                        "label": '仅本人数据权限'
                    }]
                elif item == 1:
                    data = [{
                        "value": 0,
                        "label": '仅本人数据权限'
                    }, {
                        "value": 1,
                        "label": '本部门及以下数据权限'
                    },
                        {
                            "value": 2,
                            "label": '本部门数据权限'
                        }]
                elif item == 2:
                    data = [{
                        "value": 0,
                        "label": '仅本人数据权限'
                    },
                        {
                            "value": 2,
                            "label": '本部门数据权限'
                        }]
                elif item == 3:
                    data = [{
                        "value": 0,
                        "label": '仅本人数据权限'
                    },
                        {
                            "value": 3,
                            "label": '全部数据权限'
                        }, ]
                elif item == 4:
                    data = [{
                        "value": 0,
                        "label": '仅本人数据权限'
                    },
                        {
                            "value": 4,
                            "label": '自定义数据权限'
                        }]
                else:
                    data = []
        return DetailResponse(data=data)


# 这段代码用于根据当前用户的角色获取部门信息，根据不同的角色权限不同，可以获取不同范围的部门信息。下面是加上注释后的代码：
    @action(methods=['GET'], detail=False, permission_classes=[IsAuthenticated])
    def data_scope_dept(self,request):
        """根据当前角色获取部门信息"""
        # 判断用户是否为超级用户
        is_superuser = request.user.is_superuser
        # 如果是超级用户，则获取所有部门信息
        if is_superuser:
            queryset = Dept.objects.values('id','name','parent')
        # 如果不是超级用户，则根据用户的角色获取部门信息
        else:
            # 获取用户的角色
            dept_list = request.user.role.values_list('dept',flat=True)
            # 使用部门列表过滤部门信息
            queryset = Dept.objects.filter(id__in=dept_list).values('id','name','parent')
        # 返回部门信息
        return DetailResponse(data=queryset)
